/**
 * 全局统一赔付计算器
 * 
 * 这是系统中唯一的赔付计算逻辑中心，所有投注类型的赔付计算都必须通过这里
 * 确保计算逻辑的一致性和可维护性
 */
class PayoutCalculator {
    
    /**
     * 计算潜在赔付金额
     * 这是系统中唯一的赔付计算入口，所有地方都应该调用这个方法
     * 
     * @param {Object} bet - 投注对象
     * @param {string} bet.type - 投注类型 (numbers, sides, banbo, shengxiao, weishu, buzhong, sebo, lianma)
     * @param {string} bet.game - 游戏类型 (tema, zhengma, lianma, shengxiao, weishu, buzhong, sebo, banbo)
     * @param {string} bet.sub - 子类型 (zhixuan, liangmian, renxuan, etc.)
     * @param {number} bet.amount - 单注金额
     * @param {number} bet.count - 注数
     * @param {number} bet.odds - 赔率
     * @param {Array} bet.numbers - 选择的号码
     * @param {string} bet.sideType - 两面投注类型
     * @param {Array} bet.animals - 选择的生肖
     * @param {Array} bet.tails - 选择的尾数
     * @param {Array} bet.sebo - 选择的色波
     * @param {Array} bet.selectedBanbos - 选择的半波
     * @returns {number} 潜在赔付金额
     */
    static calculatePotentialPayout(bet) {
        if (!bet || typeof bet !== 'object') {
            console.error('PayoutCalculator: 无效的投注对象', bet);
            return 0;
        }

        const amount = bet.amount || 0;
        const count = bet.count || 1;
        const odds = bet.customOdds || bet.odds || 1;
        const totalAmount = amount * count;

        // 特码直选多选的特殊处理：最多只有1注会中奖
        if (this.isTemasDirectMultiple(bet)) {
            return amount * odds;
        }

        // 连码投注的特殊处理
        if (bet.game === 'lianma') {
            return this.calculateLianmaPayout(bet, amount, odds);
        }

        // 生肖投注的特殊处理  
        if (bet.game === 'shengxiao') {
            return this.calculateShengxiaoPayout(bet, amount, odds);
        }

        // 尾数投注的特殊处理
        if (bet.game === 'weishu') {
            return this.calculateWeishuPayout(bet, amount, odds);
        }

        // 不中投注的特殊处理
        if (bet.game === 'buzhong') {
            return this.calculateBuzhongPayout(bet, amount, odds);
        }

        // 色波投注的特殊处理
        if (bet.game === 'sebo') {
            return this.calculateSeboPayout(bet, amount, odds);
        }

        // 半波投注的特殊处理
        if (bet.game === 'banbo') {
            return this.calculateBanboPayout(bet, amount, odds);
        }

        // 其他投注类型：所有注数都可能中奖
        return totalAmount * odds;
    }

    /**
     * 检查是否为特码直选多选
     * @param {Object} bet - 投注对象
     * @returns {boolean} 是否为特码直选多选
     */
    static isTemasDirectMultiple(bet) {
        return bet.type === 'numbers' && 
               bet.game === 'tema' && 
               bet.sub === 'zhixuan' && 
               bet.count > 1;
    }

    /**
     * 获取潜在赔付标签文本
     * @param {Object} bet - 投注对象
     * @returns {string} 标签文本
     */
    static getPotentialPayoutLabel(bet) {
        return this.isTemasDirectMultiple(bet) ? '最高可中' : '可中金额';
    }

    /**
     * 计算连码投注赔付
     */
    static calculateLianmaPayout(bet, amount, odds) {
        // 连码投注：根据组合数计算，但最多只有部分组合会中奖
        // 具体中奖组合数取决于开奖结果
        const totalAmount = amount * bet.count;
        
        switch (bet.sub) {
            case 'sanquanzhong': // 三全中：选中的3个号码都在正码中
            case 'sanzhonger':   // 三中二：选中的3个号码中有2个在正码中
            case 'erquanzhong':  // 二全中：选中的2个号码都在正码中
            case 'erzhongte':    // 二中特：选中的2个号码中有1个是特码
            case 'techuan':      // 特串：选中的号码组合包含特码
                return totalAmount * odds; // 所有组合都可能中奖
            default:
                return totalAmount * odds;
        }
    }

    /**
     * 计算生肖投注赔付
     */
    static calculateShengxiaoPayout(bet, amount, odds) {
        const totalAmount = amount * bet.count;
        
        switch (bet.sub) {
            case 'texiao':       // 特肖：只有特码生肖中奖
            case 'yixiao':       // 一肖：只要有一个号码是该生肖就中奖
                return amount * odds; // 单注中奖
            case 'zhengxiao':    // 正肖：根据正码中该生肖的个数计算赔付
            case 'sanxiaolian':  // 三肖连：选中的3个生肖都在开奖结果中
            case 'erxiaolian':   // 二肖连：选中的2个生肖都在开奖结果中
            case 'sixiaolian':   // 四肖连：选中的4个生肖都在开奖结果中
            case 'hexiaozhong':  // 合肖中：选中的生肖组合中奖
            case 'hexiaobuzhong': // 合肖不中：选中的生肖组合不中奖
            case 'zongxiao':     // 总肖：根据开奖结果中该生肖的总个数计算
                return totalAmount * odds; // 所有注数都可能中奖
            default:
                return totalAmount * odds;
        }
    }

    /**
     * 计算尾数投注赔付
     */
    static calculateWeishuPayout(bet, amount, odds) {
        const totalAmount = amount * bet.count;
        
        switch (bet.sub) {
            case 'zhengteweishu': // 正特尾数：根据正码和特码中该尾数的个数计算
            case 'tematouwei':    // 特码头尾：特码的头数或尾数中奖
            case 'erweilianzhong': // 二尾连中：选中的2个尾数都在开奖结果中
            case 'sanweilianzhong': // 三尾连中：选中的3个尾数都在开奖结果中
            case 'siweilianzhong':  // 四尾连中：选中的4个尾数都在开奖结果中
                return totalAmount * odds; // 所有注数都可能中奖
            default:
                return totalAmount * odds;
        }
    }

    /**
     * 计算不中投注赔付
     */
    static calculateBuzhongPayout(bet, amount, odds) {
        // 不中投注：选中的号码都不在开奖结果中才中奖
        // 这是一个整体投注，要么全中奖要么全不中奖
        const totalAmount = amount * bet.count;
        return totalAmount * odds;
    }

    /**
     * 计算色波投注赔付
     */
    static calculateSeboPayout(bet, amount, odds) {
        // 色波投注：根据七个开奖号码的色波组合计算
        // 通常是整体投注
        const totalAmount = amount * bet.count;
        return totalAmount * odds;
    }

    /**
     * 计算半波投注赔付
     */
    static calculateBanboPayout(bet, amount, odds) {
        // 半波投注：特码满足指定的颜色+大小/单双条件
        // 单一条件投注
        return amount * odds;
    }

    /**
     * 计算实际中奖赔付
     * 当实际开奖时，根据开奖结果计算实际的中奖金额
     */
    static calculateActualPayout(bet, drawResult) {
        // 实际中奖赔付的计算逻辑与潜在赔付相同
        // 区别在于需要根据实际开奖结果判断是否中奖
        return this.calculatePotentialPayout(bet);
    }

    /**
     * 获取投注类型的显示名称
     */
    static getBetTypeDisplayName(bet) {
        const gameNames = {
            'tema': '特码',
            'zhengma': '正码', 
            'lianma': '连码',
            'shengxiao': '生肖',
            'weishu': '尾数',
            'buzhong': '不中',
            'sebo': '色波',
            'banbo': '半波'
        };

        const subNames = {
            'zhixuan': '直选',
            'liangmian': '两面',
            'renxuan': '任选',
            'yite': '1特',
            'sanquanzhong': '三全中',
            'sanzhonger': '三中二',
            'erquanzhong': '二全中',
            'erzhongte': '二中特',
            'techuan': '特串',
            'texiao': '特肖',
            'zhengxiao': '正肖',
            'yixiao': '一肖',
            'zongxiao': '总肖'
        };

        const gameName = gameNames[bet.game] || bet.game;
        const subName = subNames[bet.sub] || bet.sub;
        
        return `${gameName}${subName}`;
    }

    /**
     * 验证投注对象的有效性
     */
    static validateBet(bet) {
        if (!bet || typeof bet !== 'object') {
            return { valid: false, error: '投注对象无效' };
        }

        if (!bet.amount || bet.amount <= 0) {
            return { valid: false, error: '投注金额必须大于0' };
        }

        if (!bet.count || bet.count <= 0) {
            return { valid: false, error: '投注注数必须大于0' };
        }

        if (!bet.odds || bet.odds <= 0) {
            return { valid: false, error: '赔率必须大于0' };
        }

        return { valid: true };
    }

    /**
     * 格式化金额显示
     */
    static formatAmount(amount) {
        if (typeof amount !== 'number' || isNaN(amount)) {
            return '0.00';
        }
        return amount.toFixed(2);
    }

    /**
     * 批量计算多个投注的总赔付
     */
    static calculateTotalPayout(bets) {
        if (!Array.isArray(bets)) {
            return 0;
        }

        return bets.reduce((total, bet) => {
            return total + this.calculatePotentialPayout(bet);
        }, 0);
    }

    /**
     * 获取调试信息
     */
    static getDebugInfo(bet) {
        const validation = this.validateBet(bet);
        const payout = validation.valid ? this.calculatePotentialPayout(bet) : 0;
        
        return {
            bet: bet,
            validation: validation,
            isTemasDirectMultiple: this.isTemasDirectMultiple(bet),
            calculatedPayout: payout,
            displayName: this.getBetTypeDisplayName(bet),
            timestamp: new Date().toISOString()
        };
    }
}

// 向后兼容的全局函数
window.calculatePotentialWin = function(bet) {
    console.warn('使用了过时的 calculatePotentialWin 函数，请改用 PayoutCalculator.calculatePotentialPayout');
    return PayoutCalculator.calculatePotentialPayout(bet);
};

// 导出到全局作用域
window.PayoutCalculator = PayoutCalculator;

// 如果支持模块化，也导出模块
if (typeof module !== 'undefined' && module.exports) {
    module.exports = PayoutCalculator;
} 